home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Resources / Developers / XAMPP 1.5.4 / Windows installer / xampp-win32-1.5.4-installer.exe / xampp / phpMyAdmin / libraries / database_interface.lib.php < prev    next >
Encoding:
PHP Script  |  2006-03-08  |  39.8 KB  |  1,038 lines
  1. <?php
  2. /* $Id: database_interface.lib.php,v 2.39.2.2 2006/03/08 17:54:29 lem9 Exp $ */
  3. // vim: expandtab sw=4 ts=4 sts=4:
  4.  
  5. /**
  6.  * Common Option Constants For DBI Functions
  7.  */
  8. // PMA_DBI_try_query()
  9. define('PMA_DBI_QUERY_STORE',       1);  // Force STORE_RESULT method, ignored by classic MySQL.
  10. define('PMA_DBI_QUERY_UNBUFFERED',  2);  // Do not read whole query
  11. // PMA_DBI_get_variable()
  12. define('PMA_DBI_GETVAR_SESSION', 1);
  13. define('PMA_DBI_GETVAR_GLOBAL', 2);
  14.  
  15. /**
  16.  * Loads the mysql extensions if it is not loaded yet
  17.  *
  18.  * @param   string  $extension  mysql extension to load
  19.  */
  20. function PMA_DBI_checkAndLoadMysqlExtension( $extension = 'mysql' ) {
  21.     if ( ! function_exists( $extension . '_connect' ) ) {
  22.         PMA_dl( $extension );
  23.         // check whether mysql is available
  24.         if ( ! function_exists( $extension . '_connect' ) ) {
  25.             return false;
  26.         }
  27.     }
  28.  
  29.     return true;
  30. }
  31.  
  32.  
  33. /**
  34.  * check for requested extension
  35.  */
  36. if ( ! PMA_DBI_checkAndLoadMysqlExtension( $GLOBALS['cfg']['Server']['extension'] ) ) {
  37.  
  38.     // if it fails try alternative extension ...
  39.     // and display an error ...
  40.  
  41.     // TODO 2.7.1: add different messages for alternativ extension
  42.     // and complete fail (no alternativ extension too)
  43.     $GLOBALS['PMA_errors'][] =
  44.         sprintf( PMA_sanitize( $GLOBALS['strCantLoad'] ),
  45.             $GLOBALS['cfg']['Server']['extension'] )
  46.         .' - <a href="./Documentation.html#faqmysql" target="documentation">'
  47.         .$GLOBALS['strDocu'] . '</a>';
  48.  
  49.     if ( $GLOBALS['cfg']['Server']['extension'] === 'mysql' ) {
  50.         $alternativ_extension = 'mysqli';
  51.     } else {
  52.         $alternativ_extension = 'mysql';
  53.     }
  54.  
  55.     if ( ! PMA_DBI_checkAndLoadMysqlExtension( $alternativ_extension ) ) {
  56.         // if alternativ fails too ...
  57.         header( 'Location: error.php'
  58.                 . '?lang='  . urlencode( $available_languages[$lang][2] )
  59.                 . '&char='  . urlencode( $charset )
  60.                 . '&dir='   . urlencode( $text_dir )
  61.                 . '&type='  . urlencode( $strError )
  62.                 . '&error=' . urlencode(
  63.                     sprintf( $GLOBALS['strCantLoad'],
  64.                         $GLOBALS['cfg']['Server']['extension'] )
  65.                     .' - [a@./Documentation.html#faqmysql@documentation]'
  66.                     .$GLOBALS['strDocu'] . '[/a]' )
  67.                 . '&' . SID
  68.                  );
  69.         exit();
  70.     }
  71.  
  72.     $GLOBALS['cfg']['Server']['extension'] = $alternativ_extension;
  73.     unset( $alternativ_extension );
  74. }
  75.  
  76. /**
  77.  * Including The DBI Plugin
  78.  */
  79. require_once('./libraries/dbi/' . $GLOBALS['cfg']['Server']['extension'] . '.dbi.lib.php');
  80.  
  81. /**
  82.  * Common Functions
  83.  */
  84. function PMA_DBI_query($query, $link = null, $options = 0) {
  85.     $res = PMA_DBI_try_query($query, $link, $options)
  86.         or PMA_mysqlDie(PMA_DBI_getError($link), $query);
  87.     return $res;
  88. }
  89.  
  90. /**
  91.  * converts charset of a mysql message, usally coming from mysql_error(),
  92.  * into PMA charset, usally UTF-8
  93.  * uses language to charset mapping from mysql/share/errmsg.txt
  94.  * and charset names to ISO charset from information_schema.CHARACTER_SETS
  95.  *
  96.  * @uses    $GLOBALS['cfg']['IconvExtraParams']
  97.  * @uses    $GLOBALS['charset']     as target charset
  98.  * @uses    PMA_DBI_fetch_value()   to get server_language
  99.  * @uses    preg_match()            to filter server_language
  100.  * @uses    in_array()
  101.  * @uses    function_exists()       to check for a convert function
  102.  * @uses    iconv()                 to convert message
  103.  * @uses    libiconv()              to convert message
  104.  * @uses    recode_string()         to convert message
  105.  * @uses    mb_convert_encoding()   to convert message
  106.  * @param   string  $message
  107.  * @return  string  $message
  108.  */
  109. function PMA_DBI_convert_message( $message ) {
  110.     // latin always last!
  111.     $encodings = array(
  112.         'japanese'      => 'EUC-JP', //'ujis',
  113.         'japanese-sjis' => 'Shift-JIS', //'sjis',
  114.         'korean'        => 'EUC-KR', //'euckr',
  115.         'russian'       => 'KOI8-R', //'koi8r',
  116.         'ukrainian'     => 'KOI8-U', //'koi8u',
  117.         'greek'         => 'ISO-8859-7', //'greek',
  118.         'serbian'       => 'CP1250', //'cp1250',
  119.         'estonian'      => 'ISO-8859-13', //'latin7',
  120.         'slovak'        => 'ISO-8859-2', //'latin2',
  121.         'czech'         => 'ISO-8859-2', //'latin2',
  122.         'hungarian'     => 'ISO-8859-2', //'latin2',
  123.         'polish'        => 'ISO-8859-2', //'latin2',
  124.         'romanian'      => 'ISO-8859-2', //'latin2',
  125.         'spanish'       => 'CP1252', //'latin1',
  126.         'swedish'       => 'CP1252', //'latin1',
  127.         'italian'       => 'CP1252', //'latin1',
  128.         'norwegian-ny'  => 'CP1252', //'latin1',
  129.         'norwegian'     => 'CP1252', //'latin1',
  130.         'portuguese'    => 'CP1252', //'latin1',
  131.         'danish'        => 'CP1252', //'latin1',
  132.         'dutch'         => 'CP1252', //'latin1',
  133.         'english'       => 'CP1252', //'latin1',
  134.         'french'        => 'CP1252', //'latin1',
  135.         'german'        => 'CP1252', //'latin1',
  136.     );
  137.  
  138.     if ( $server_language = PMA_DBI_fetch_value( 'SHOW VARIABLES LIKE \'language\';', 0, 1 ) ) {
  139.         $found = array();
  140.         if ( preg_match( '&(?:\\\|\\/)([^\\\\\/]*)(?:\\\|\\/)$&i', $server_language, $found )) {
  141.             $server_language = $found[1];
  142.         }
  143.     }
  144.  
  145.     if ( ! empty( $server_language ) && isset( $encodings[$server_language] ) ) {
  146.         if ( function_exists( 'iconv' ) ) {
  147.             $message = iconv( $encodings[$server_language],
  148.                 $GLOBALS['charset'] . $GLOBALS['cfg']['IconvExtraParams'], $message);
  149.         } elseif ( function_exists( 'recode_string' ) ) {
  150.             $message = recode_string( $encodings[$server_language] . '..'  . $GLOBALS['charset'],
  151.                 $message );
  152.         } elseif ( function_exists( 'libiconv' ) ) {
  153.             $message = libiconv( $encodings[$server_language], $GLOBALS['charset'], $message );
  154.         } elseif ( function_exists( 'mb_convert_encoding' ) ) {
  155.             // do not try unsupported charsets
  156.             if ( ! in_array( $server_language, array( 'ukrainian', 'greek', 'serbian' ) ) ) {
  157.                 $message = mb_convert_encoding( $message, $GLOBALS['charset'],
  158.                     $encodings[$server_language] );
  159.             }
  160.         }
  161.     } else {
  162.         // lang not found, try all
  163.         // what TODO ?
  164.     }
  165.  
  166.     return $message;
  167. }
  168.  
  169. /**
  170.  * returns array with database names
  171.  *
  172.  * @return  array   $databases
  173.  */
  174. function PMA_DBI_get_dblist($link = null)
  175. {
  176.     $dbs_array = PMA_DBI_fetch_result('SHOW DATABASES;', $link);
  177.  
  178.     // Before MySQL 4.0.2, SHOW DATABASES could send the
  179.     // whole list, so check if we really have access:
  180.     if (PMA_MYSQL_INT_VERSION < 40002 || !empty($GLOBALS['cfg']['Server']['hide_db'])) {
  181.         foreach ($dbs_array as $key => $db) {
  182.             if (!@PMA_DBI_select_db($db, $link) || (!empty($GLOBALS['cfg']['Server']['hide_db']) && preg_match('/' . $GLOBALS['cfg']['Server']['hide_db'] . '/', $db))) {
  183.                 unset( $dbs_array[$key] );
  184.             }
  185.         }
  186.         // re-index values
  187.         $dbs_array = array_values( $dbs_array );
  188.     }
  189.  
  190.     return $dbs_array;
  191. }
  192.  
  193. /**
  194.  * returns array with table names for given db
  195.  *
  196.  * @param   string  $database   name of database
  197.  * @param   mixed   $link       mysql link resource|object
  198.  * @return  array   tables names
  199.  */
  200. function PMA_DBI_get_tables($database, $link = null)
  201. {
  202.     return PMA_DBI_fetch_result('SHOW TABLES FROM ' . PMA_backquote($database) . ';',
  203.         null, 0, $link, PMA_DBI_QUERY_STORE);
  204. }
  205.  
  206. /**
  207.  * returns array of all tables in given db or dbs
  208.  * this function expects unqoted names:
  209.  * RIGHT: my_database
  210.  * WRONG: `my_database`
  211.  * WRONG: my\_database
  212.  * if $tbl_is_group is true, $table is used as filter for table names
  213.  * if $tbl_is_group is 'comment, $table is used as filter for table comments
  214.  *
  215.  * <code>
  216.  * PMA_DBI_get_tables_full( 'my_database' );
  217.  * PMA_DBI_get_tables_full( 'my_database', 'my_table' ) );
  218.  * PMA_DBI_get_tables_full( 'my_database', 'my_tables_', true ) );
  219.  * PMA_DBI_get_tables_full( 'my_database', 'my_tables_', 'comment' ) );
  220.  * </code>
  221.  *
  222.  * @uses    PMA_MYSQL_INT_VERSION
  223.  * @uses    PMA_DBI_fetch_result()
  224.  * @uses    PMA_escape_mysql_wildcards()
  225.  * @uses    PMA_backquote()
  226.  * @uses    is_array()
  227.  * @uses    addslashes()
  228.  * @uses    strpos()
  229.  * @uses    strtoupper()
  230.  * @param   string          $databases      database
  231.  * @param   string          $table          table
  232.  * @param   boolean|string  $tbl_is_group   $table is a table group
  233.  * @param   resource        $link           mysql link
  234.  * @return  array           list of tbales in given db(s)
  235.  */
  236. function PMA_DBI_get_tables_full($database, $table = false,
  237.     $tbl_is_group = false, $link = null)
  238. {
  239.     // prepare and check parameters
  240.     if ( ! is_array($database) ) {
  241.         $databases = array(addslashes($database));
  242.     } else {
  243.         $databases = array_map('addslashes', $database);
  244.     }
  245.  
  246.     $tables = array();
  247.  
  248.     if ( PMA_MYSQL_INT_VERSION >= 50002 ) {
  249.         // get table information from information_schema
  250.         if ( $table ) {
  251.             if ( true === $tbl_is_group ) {
  252.                 $sql_where_table = 'AND `TABLE_NAME` LIKE \''
  253.                     . PMA_escape_mysql_wildcards(addslashes($table)) . '%\'';
  254.             } elseif ( 'comment' === $tbl_is_group ) {
  255.                 $sql_where_table = 'AND `TABLE_COMMENT` LIKE \''
  256.                     . PMA_escape_mysql_wildcards(addslashes($table)) . '%\'';
  257.             } else {
  258.                 $sql_where_table = 'AND `TABLE_NAME` = \'' . addslashes($table) . '\'';
  259.             }
  260.         } else {
  261.             $sql_where_table = '';
  262.         }
  263.  
  264.         // for PMA bc:
  265.         // `SCHEMA_FIELD_NAME` AS `SHOW_TABLE_STATUS_FIELD_NAME`
  266.         $sql = '
  267.              SELECT *,
  268.                     `TABLE_SCHEMA`       AS `Db`,
  269.                     `TABLE_NAME`         AS `Name`,
  270.                     `ENGINE`             AS `Engine`,
  271.                     `ENGINE`             AS `Type`,
  272.                     `VERSION`            AS `Version`,
  273.                     `ROW_FORMAT`         AS `Row_format`,
  274.                     `TABLE_ROWS`         AS `Rows`,
  275.                     `AVG_ROW_LENGTH`     AS `Avg_row_length`,
  276.                     `DATA_LENGTH`        AS `Data_length`,
  277.                     `MAX_DATA_LENGTH`    AS `Max_data_length`,
  278.                     `INDEX_LENGTH`       AS `Index_length`,
  279.                     `DATA_FREE`          AS `Data_free`,
  280.                     `AUTO_INCREMENT`     AS `Auto_increment`,
  281.                     `CREATE_TIME`        AS `Create_time`,
  282.                     `UPDATE_TIME`        AS `Update_time`,
  283.                     `CHECK_TIME`         AS `Check_time`,
  284.                     `TABLE_COLLATION`    AS `Collation`,
  285.                     `CHECKSUM`           AS `Checksum`,
  286.                     `CREATE_OPTIONS`     AS `Create_options`,
  287.                     `TABLE_COMMENT`      AS `Comment`
  288.                FROM `information_schema`.`TABLES`
  289.               WHERE `TABLE_SCHEMA` IN (\'' . implode("', '", $databases) . '\')
  290.                 ' . $sql_where_table;
  291.         $tables = PMA_DBI_fetch_result($sql, array('TABLE_SCHEMA', 'TABLE_NAME'),
  292.             null, $link);
  293.         unset( $sql_where_table, $sql );
  294.     } else {
  295.         foreach ( $databases as $each_database ) {
  296.             if ( true === $tbl_is_group ) {
  297.                 $sql = 'SHOW TABLE STATUS FROM '
  298.                     . PMA_backquote($each_database)
  299.                     .' LIKE \'' . PMA_escape_mysql_wildcards(addslashes($table)) . '%\'';
  300.             } else {
  301.                 $sql = 'SHOW TABLE STATUS FROM '
  302.                     . PMA_backquote($each_database) . ';';
  303.             }
  304.             $each_tables = PMA_DBI_fetch_result($sql, 'Name', null, $link);
  305.             foreach ( $each_tables as $table_name => $each_table ) {
  306.                 if ( 'comment' === $tbl_is_group
  307.                   && 0 === strpos($each_table['Comment'], $table) )
  308.                 {
  309.                     // remove table from list
  310.                     unset( $each_tables[$table_name] );
  311.                     continue;
  312.                 }
  313.  
  314.                 if ( ! isset( $each_tables[$table_name]['Type'] )
  315.                   && isset( $each_tables[$table_name]['Engine'] ) ) {
  316.                     // pma BC, same parts of PMA still uses 'Type'
  317.                     $each_tables[$table_name]['Type']
  318.                         =& $each_tables[$table_name]['Engine'];
  319.                 } elseif ( ! isset( $each_tables[$table_name]['Engine'] )
  320.                   && isset( $each_tables[$table_name]['Type'] ) ) {
  321.                     // old MySQL reports Type, newer MySQL reports Engine
  322.                     $each_tables[$table_name]['Engine']
  323.                         =& $each_tables[$table_name]['Type'];
  324.                 }
  325.  
  326.                 // MySQL forward compatibility
  327.                 // so pma could use this array as if every server is of version >5.0
  328.                 $each_tables[$table_name]['TABLE_SCHEMA']      = $each_database;
  329.                 $each_tables[$table_name]['TABLE_NAME']        =& $each_tables[$table_name]['Name'];
  330.                 $each_tables[$table_name]['ENGINE']            =& $each_tables[$table_name]['Engine'];
  331.                 $each_tables[$table_name]['VERSION']           =& $each_tables[$table_name]['Version'];
  332.                 $each_tables[$table_name]['ROW_FORMAT']        =& $each_tables[$table_name]['Row_format'];
  333.                 $each_tables[$table_name]['TABLE_ROWS']        =& $each_tables[$table_name]['Rows'];
  334.                 $each_tables[$table_name]['AVG_ROW_LENGTH']    =& $each_tables[$table_name]['Avg_row_length'];
  335.                 $each_tables[$table_name]['DATA_LENGTH']       =& $each_tables[$table_name]['Data_length'];
  336.                 $each_tables[$table_name]['MAX_DATA_LENGTH']   =& $each_tables[$table_name]['Max_data_length'];
  337.                 $each_tables[$table_name]['INDEX_LENGTH']      =& $each_tables[$table_name]['Index_length'];
  338.                 $each_tables[$table_name]['DATA_FREE']         =& $each_tables[$table_name]['Data_free'];
  339.                 $each_tables[$table_name]['AUTO_INCREMENT']    =& $each_tables[$table_name]['Auto_increment'];
  340.                 $each_tables[$table_name]['CREATE_TIME']       =& $each_tables[$table_name]['Create_time'];
  341.                 $each_tables[$table_name]['UPDATE_TIME']       =& $each_tables[$table_name]['Update_time'];
  342.                 $each_tables[$table_name]['CHECK_TIME']        =& $each_tables[$table_name]['Check_time'];
  343.                 $each_tables[$table_name]['TABLE_COLLATION']   =& $each_tables[$table_name]['Collation'];
  344.                 $each_tables[$table_name]['CHECKSUM']          =& $each_tables[$table_name]['Checksum'];
  345.                 $each_tables[$table_name]['CREATE_OPTIONS']    =& $each_tables[$table_name]['Create_options'];
  346.                 $each_tables[$table_name]['TABLE_COMMENT']     =& $each_tables[$table_name]['Comment'];
  347.  
  348.                 if ( strtoupper( $each_tables[$table_name]['Comment'] ) === 'VIEW' ) {
  349.                     $each_tables[$table_name]['TABLE_TYPE'] = 'VIEW';
  350.                 } else {
  351.                     // TODO difference between 'TEMPORARY' and 'BASE TABLE'
  352.                     // but how to detect?
  353.                     $each_tables[$table_name]['TABLE_TYPE'] = 'BASE TABLE';
  354.                 }
  355.             }
  356.  
  357.             $tables[$each_database] = $each_tables;
  358.         }
  359.     }
  360.  
  361.     if ( $GLOBALS['cfg']['NaturalOrder'] ) {
  362.         foreach ( $tables as $key => $val ) {
  363.             uksort($tables[$key], 'strnatcasecmp');
  364.         }
  365.     }
  366.  
  367.     if (! is_array($database)) {
  368.         if (isset($tables[$database])) {
  369.             return $tables[$database];
  370.         } elseif (isset($tables[strtolower($database)])) {
  371.             // on windows with lower_case_table_names = 1
  372.             // MySQL returns
  373.             // with SHOW DATABASES or information_schema.SCHEMATA: `Test`
  374.             // but information_schema.TABLES gives `test`
  375.             // bug #1436171
  376.             // sf.net/tracker/?func=detail&aid=1436171&group_id=23067&atid=377408
  377.             return $tables[strtolower($database)];
  378.         } else {
  379.             return $tables;
  380.         }
  381.     } else {
  382.         return $tables;
  383.     }
  384. }
  385.  
  386. /**
  387.  * returns array with databases containing extended infos about them
  388.  *
  389.  * @param   string          $databases      database
  390.  * @param   boolean         $force_stats    retrieve stats also for MySQL < 5
  391.  * @param   resource        $link           mysql link
  392.  * @return  array       $databases
  393.  */
  394. function PMA_DBI_get_databases_full( $database = null, $force_stats = false, $link = null ) {
  395.  
  396.     // initialize to avoid errors when there are no databases
  397.     $databases = array();
  398.  
  399.     if ( PMA_MYSQL_INT_VERSION >= 50002 ) {
  400.         // get table information from information_schema
  401.         if ( $database ) {
  402.             $sql_where_schema = 'WHERE `SCHEMA_NAME` LIKE \''
  403.                 . addslashes( $database ) . '\'';
  404.         } else {
  405.             $sql_where_schema = '';
  406.         }
  407.  
  408.         // for PMA bc:
  409.         // `SCHEMA_FIELD_NAME` AS `SHOW_TABLE_STATUS_FIELD_NAME`
  410.         $sql = '
  411.              SELECT `information_schema`.`SCHEMATA`.*,
  412.                     COUNT(`information_schema`.`TABLES`.`TABLE_SCHEMA`)
  413.                         AS `SCHEMA_TABLES`,
  414.                     SUM(`information_schema`.`TABLES`.`TABLE_ROWS`)
  415.                         AS `SCHEMA_TABLE_ROWS`,
  416.                     SUM(`information_schema`.`TABLES`.`DATA_LENGTH`)
  417.                         AS `SCHEMA_DATA_LENGTH`,
  418.                     SUM(`information_schema`.`TABLES`.`MAX_DATA_LENGTH`)
  419.                         AS `SCHEMA_MAX_DATA_LENGTH`,
  420.                     SUM(`information_schema`.`TABLES`.`INDEX_LENGTH`)
  421.                         AS `SCHEMA_INDEX_LENGTH`,
  422.                     SUM(`information_schema`.`TABLES`.`DATA_LENGTH`
  423.                       + `information_schema`.`TABLES`.`INDEX_LENGTH`)
  424.                         AS `SCHEMA_LENGTH`,
  425.                     SUM(`information_schema`.`TABLES`.`DATA_FREE`)
  426.                         AS `SCHEMA_DATA_FREE`
  427.                FROM `information_schema`.`SCHEMATA`
  428.           LEFT JOIN `information_schema`.`TABLES`
  429.                  ON `information_schema`.`TABLES`.`TABLE_SCHEMA`
  430.                   = `information_schema`.`SCHEMATA`.`SCHEMA_NAME`
  431.               ' . $sql_where_schema . '
  432.            GROUP BY `information_schema`.`SCHEMATA`.`SCHEMA_NAME`';
  433.         $databases = PMA_DBI_fetch_result( $sql, 'SCHEMA_NAME', null, $link );
  434.         unset( $sql_where_schema, $sql );
  435.     } else {
  436.         foreach ( PMA_DBI_get_dblist( $link ) as $database_name ) {
  437.             // MySQL forward compatibility
  438.             // so pma could use this array as if every server is of version >5.0
  439.             $databases[$database_name]['SCHEMA_NAME']      = $database_name;
  440.  
  441.             if ( $force_stats ) {
  442.                 require_once 'mysql_charsets.lib.php';
  443.  
  444.                 $databases[$database_name]['DEFAULT_COLLATION_NAME']
  445.                     = PMA_getDbCollation( $database_name );
  446.  
  447.                 // get additonal info about tables
  448.                 $databases[$database_name]['SCHEMA_TABLES']          = 0;
  449.                 $databases[$database_name]['SCHEMA_TABLE_ROWS']      = 0;
  450.                 $databases[$database_name]['SCHEMA_DATA_LENGTH']     = 0;
  451.                 $databases[$database_name]['SCHEMA_MAX_DATA_LENGTH'] = 0;
  452.                 $databases[$database_name]['SCHEMA_INDEX_LENGTH']    = 0;
  453.                 $databases[$database_name]['SCHEMA_LENGTH']          = 0;
  454.                 $databases[$database_name]['SCHEMA_DATA_FREE']       = 0;
  455.  
  456.                 $res = PMA_DBI_query('SHOW TABLE STATUS FROM ' . PMA_backquote( $database_name ) . ';');
  457.                 while ( $row = PMA_DBI_fetch_assoc( $res ) ) {
  458.                     $databases[$database_name]['SCHEMA_TABLES']++;
  459.                     $databases[$database_name]['SCHEMA_TABLE_ROWS']
  460.                         += $row['Rows'];
  461.                     $databases[$database_name]['SCHEMA_DATA_LENGTH']
  462.                         += $row['Data_length'];
  463.                     $databases[$database_name]['SCHEMA_MAX_DATA_LENGTH']
  464.                         += $row['Max_data_length'];
  465.                     $databases[$database_name]['SCHEMA_INDEX_LENGTH']
  466.                         += $row['Index_length'];
  467.                     $databases[$database_name]['SCHEMA_DATA_FREE']
  468.                         += $row['Data_free'];
  469.                     $databases[$database_name]['SCHEMA_LENGTH']
  470.                         += $row['Data_length'] + $row['Index_length'];
  471.                 }
  472.                 PMA_DBI_free_result( $res );
  473.                 unset( $res );
  474.             }
  475.         }
  476.     }
  477.  
  478.     if ( $GLOBALS['cfg']['NaturalOrder'] ) {
  479.         uksort( $databases, 'strnatcasecmp' );
  480.     }
  481.  
  482.     return $databases;
  483. }
  484.  
  485. /**
  486.  * returns detailed array with all columns for given table in database,
  487.  * or all tables/databases
  488.  *
  489.  * @param   string  $database   name of database
  490.  * @param   string  $table      name of table to retrieve columns from
  491.  * @param   string  $column     name of specific column
  492.  * @param   mixed   $link       mysql link resource
  493.  */
  494. function PMA_DBI_get_columns_full($database = null, $table = null,
  495.     $column = null, $link = null)
  496. {
  497.     $columns = array();
  498.  
  499.     if ( PMA_MYSQL_INT_VERSION >= 50002 ) {
  500.         $sql_wheres = array();
  501.         $array_keys = array();
  502.  
  503.         // get columns information from information_schema
  504.         if ( null !== $database ) {
  505.             $sql_wheres[] = '`TABLE_SCHEMA` = \'' . addslashes($database) . '\' ';
  506.         } else {
  507.             $array_keys[] = 'TABLE_SCHEMA';
  508.         }
  509.         if (  null !== $table ) {
  510.             $sql_wheres[] = '`TABLE_NAME` = \'' . addslashes($table) . '\' ';
  511.         } else {
  512.             $array_keys[] = 'TABLE_NAME';
  513.         }
  514.         if (  null !== $column ) {
  515.             $sql_wheres[] = '`COLUMN_NAME` = \'' . addslashes($column) . '\' ';
  516.         } else {
  517.             $array_keys[] = 'COLUMN_NAME';
  518.         }
  519.  
  520.         // for PMA bc:
  521.         // `[SCHEMA_FIELD_NAME]` AS `[SHOW_FULL_COLUMNS_FIELD_NAME]`
  522.         $sql = '
  523.              SELECT *,
  524.                     `COLUMN_NAME`       AS `Field`,
  525.                     `COLUMN_TYPE`       AS `Type`,
  526.                     `COLLATION_NAME`    AS `Collation`,
  527.                     `IS_NULLABLE`       AS `Null`,
  528.                     `COLUMN_KEY`        AS `Key`,
  529.                     `COLUMN_DEFAULT`    AS `Default`,
  530.                     `EXTRA`             AS `Extra`,
  531.                     `PRIVILEGES`        AS `Privileges`,
  532.                     `COLUMN_COMMENT`    AS `Comment`
  533.                FROM `information_schema`.`COLUMNS`';
  534.         if ( count($sql_wheres) ) {
  535.             $sql .= "\n" . ' WHERE ' . implode(' AND ', $sql_wheres);
  536.         }
  537.  
  538.         $columns = PMA_DBI_fetch_result($sql, $array_keys, null, $link);
  539.         unset( $sql_wheres, $sql );
  540.     } else {
  541.         if ( null === $database ) {
  542.             $databases = PMA_DBI_get_dblist();
  543.             foreach ( $databases as $database ) {
  544.                 $columns[$database] = PMA_DBI_get_columns_full($database, null,
  545.                     null, $link);
  546.             }
  547.             return $columns;
  548.         } elseif ( null === $table ) {
  549.             $tables = PMA_DBI_get_tables($database);
  550.             foreach ( $tables as $table ) {
  551.                 $columns[$table] = PMA_DBI_get_columns_full(
  552.                     $database, $table, null, $link);
  553.             }
  554.             return $columns;
  555.         }
  556.  
  557.         $sql = 'SHOW FULL COLUMNS FROM '
  558.             . PMA_backquote($database) . '.' . PMA_backquote($table);
  559.         if ( null !== $column ) {
  560.             $sql .= " LIKE '" . $column . "'";
  561.         }
  562.  
  563.         $columns = PMA_DBI_fetch_result( $sql, 'Field', null, $link );
  564.  
  565.         $ordinal_position = 1;
  566.         foreach ( $columns as $column_name => $each_column ) {
  567.  
  568.             // MySQL forward compatibility
  569.             // so pma could use this array as if every server is of version >5.0
  570.             $columns[$column_name]['COLUMN_NAME']                 =& $columns[$column_name]['Field'];
  571.             $columns[$column_name]['COLUMN_TYPE']                 =& $columns[$column_name]['Type'];
  572.             $columns[$column_name]['COLLATION_NAME']              =& $columns[$column_name]['Collation'];
  573.             $columns[$column_name]['IS_NULLABLE']                 =& $columns[$column_name]['Null'];
  574.             $columns[$column_name]['COLUMN_KEY']                  =& $columns[$column_name]['Key'];
  575.             $columns[$column_name]['COLUMN_DEFAULT']              =& $columns[$column_name]['Default'];
  576.             $columns[$column_name]['EXTRA']                       =& $columns[$column_name]['Extra'];
  577.             $columns[$column_name]['PRIVILEGES']                  =& $columns[$column_name]['Privileges'];
  578.             $columns[$column_name]['COLUMN_COMMENT']              =& $columns[$column_name]['Comment'];
  579.  
  580.             $columns[$column_name]['TABLE_CATALOG']               = null;
  581.             $columns[$column_name]['TABLE_SCHEMA']                = $database;
  582.             $columns[$column_name]['TABLE_NAME']                  = $table;
  583.             $columns[$column_name]['ORDINAL_POSITION']            = $ordinal_position;
  584.             $columns[$column_name]['DATA_TYPE']                   =
  585.                 substr($columns[$column_name]['COLUMN_TYPE'], 0,
  586.                     strpos($columns[$column_name]['COLUMN_TYPE'], '('));
  587.             // @TODO guess CHARACTER_MAXIMUM_LENGTH from COLUMN_TYPE
  588.             $columns[$column_name]['CHARACTER_MAXIMUM_LENGTH']    = null;
  589.             // @TODO guess CHARACTER_OCTET_LENGTH from CHARACTER_MAXIMUM_LENGTH
  590.             $columns[$column_name]['CHARACTER_OCTET_LENGTH']      = null;
  591.             $columns[$column_name]['NUMERIC_PRECISION']           = null;
  592.             $columns[$column_name]['NUMERIC_SCALE']               = null;
  593.             $columns[$column_name]['CHARACTER_SET_NAME']          =
  594.                 substr($columns[$column_name]['COLLATION_NAME'], 0,
  595.                     strpos($columns[$column_name]['COLLATION_NAME'], '_'));
  596.  
  597.             $ordinal_position++;
  598.         }
  599.  
  600.         if ( null !== $column ) {
  601.             reset($columns);
  602.             $columns = current($columns);
  603.         }
  604.     }
  605.  
  606.     return $columns;
  607. }
  608.  
  609. /**
  610.  * @TODO should only return columns names, for more info use PMA_DBI_get_columns_full()
  611.  *
  612.  * @param   string  $database   name of database
  613.  * @param   string  $table      name of table to retrieve columns from
  614.  * @param   mixed   $link       mysql link resource
  615.  */
  616. function PMA_DBI_get_fields($database, $table, $link = null)
  617. {
  618.     // here we use a try_query because when coming from
  619.     // tbl_create + tbl_properties.inc.php, the table does not exist
  620.     $fields = PMA_DBI_fetch_result(
  621.         'SHOW FULL COLUMNS
  622.         FROM ' . PMA_backquote($database) . '.' . PMA_backquote($table),
  623.         null, null, $link);
  624.     if ( ! is_array($fields) || count($fields) < 1 ) {
  625.         return false;
  626.     }
  627.     return $fields;
  628. }
  629.  
  630. /**
  631.  * returns value of given mysql server variable
  632.  *
  633.  * @param   string  $var    mysql server variable name
  634.  * @param   int     $type   PMA_DBI_GETVAR_SESSION|PMA_DBI_GETVAR_GLOBAL
  635.  * @param   mixed   $link   mysql link resource|object
  636.  * @return  mixed   value for mysql server variable
  637.  */
  638. function PMA_DBI_get_variable($var, $type = PMA_DBI_GETVAR_SESSION, $link = null)
  639. {
  640.     if ($link === null) {
  641.         if (isset($GLOBALS['userlink'])) {
  642.             $link = $GLOBALS['userlink'];
  643.         } else {
  644.             return false;
  645.         }
  646.     }
  647.     if (PMA_MYSQL_INT_VERSION < 40002) {
  648.         $type = 0;
  649.     }
  650.     switch ($type) {
  651.         case PMA_DBI_GETVAR_SESSION:
  652.             $modifier = ' SESSION';
  653.             break;
  654.         case PMA_DBI_GETVAR_GLOBAL:
  655.             $modifier = ' GLOBAL';
  656.             break;
  657.         default:
  658.             $modifier = '';
  659.     }
  660.     return PMA_DBI_fetch_value(
  661.         'SHOW' . $modifier . ' VARIABLES LIKE \'' . $var . '\';', 0, 1, $link);
  662. }
  663.  
  664. /**
  665.  * @uses    ./libraries/charset_conversion.lib.php
  666.  * @uses    PMA_DBI_QUERY_STORE
  667.  * @uses    PMA_REMOVED_NON_UTF_8
  668.  * @uses    PMA_MYSQL_INT_VERSION
  669.  * @uses    PMA_MYSQL_STR_VERSION
  670.  * @uses    PMA_DBI_GETVAR_SESSION
  671.  * @uses    PMA_DBI_fetch_value()
  672.  * @uses    PMA_DBI_query()
  673.  * @uses    PMA_DBI_get_variable()
  674.  * @uses    $GLOBALS['collation_connection']
  675.  * @uses    $GLOBALS['charset_connection']
  676.  * @uses    $GLOBALS['available_languages']
  677.  * @uses    $GLOBALS['mysql_charset_map']
  678.  * @uses    $GLOBALS['charset']
  679.  * @uses    $GLOBALS['lang']
  680.  * @uses    $GLOBALS['cfg']['Lang']
  681.  * @uses    $GLOBALS['cfg']['ColumnTypes']
  682.  * @uses    defined()
  683.  * @uses    explode()
  684.  * @uses    sprintf()
  685.  * @uses    intval()
  686.  * @uses    define()
  687.  * @uses    defined()
  688.  * @uses    substr()
  689.  * @uses    count()
  690.  * @param   mixed   $link   mysql link resource|object
  691.  * @param   boolean $is_controluser
  692.  */
  693. function PMA_DBI_postConnect($link, $is_controluser = false)
  694. {
  695.     if (!defined('PMA_MYSQL_INT_VERSION')) {
  696.         $mysql_version = PMA_DBI_fetch_value(
  697.             'SELECT VERSION()', 0, 0, $link, PMA_DBI_QUERY_STORE);
  698.         if ( $mysql_version ) {
  699.             $match = explode('.', $mysql_version);
  700.             define('PMA_MYSQL_INT_VERSION',
  701.                 (int) sprintf('%d%02d%02d', $match[0], $match[1],
  702.                         intval($match[2])));
  703.             define('PMA_MYSQL_STR_VERSION', $mysql_version);
  704.             unset($mysql_version, $match);
  705.         } else {
  706.             define('PMA_MYSQL_INT_VERSION', 32332);
  707.             define('PMA_MYSQL_STR_VERSION', '3.23.32');
  708.         }
  709.     }
  710.  
  711.     if (!defined('PMA_ENGINE_KEYWORD')) {
  712.         if (PMA_MYSQL_INT_VERSION >= 40102) {
  713.             define('PMA_ENGINE_KEYWORD','ENGINE');
  714.         } else {
  715.             define('PMA_ENGINE_KEYWORD','TYPE');
  716.         }
  717.     }
  718.  
  719.     if (PMA_MYSQL_INT_VERSION >= 40100) {
  720.  
  721.         // If $lang is defined and we are on MySQL >= 4.1.x,
  722.         // we auto-switch the lang to its UTF-8 version (if it exists and user
  723.         // didn't force language)
  724.         if ( !empty($GLOBALS['lang'])
  725.           && (substr($GLOBALS['lang'], -5) != 'utf-8')
  726.           && !isset($GLOBALS['cfg']['Lang']) ) {
  727.             $lang_utf_8_version =
  728.                 substr($GLOBALS['lang'], 0, strpos($GLOBALS['lang'], '-'))
  729.                 . '-utf-8';
  730.             if (!empty($GLOBALS['available_languages'][$lang_utf_8_version])) {
  731.                 $GLOBALS['lang'] = $lang_utf_8_version;
  732.                 $GLOBALS['charset'] = 'utf-8';
  733.             }
  734.         }
  735.  
  736.         // and we remove the non-UTF-8 choices to avoid confusion
  737.         if (!defined('PMA_REMOVED_NON_UTF_8')) {
  738.             foreach ( $GLOBALS['available_languages'] as $each_lang => $dummy ) {
  739.                 if ( substr($each_lang, -5) != 'utf-8' ) {
  740.                     unset( $GLOBALS['available_languages'][$each_lang] );
  741.                 }
  742.             }
  743.             define('PMA_REMOVED_NON_UTF_8', 1);
  744.         }
  745.  
  746.         $mysql_charset = $GLOBALS['mysql_charset_map'][$GLOBALS['charset']];
  747.         if ( $is_controluser
  748.           || empty($GLOBALS['collation_connection'])
  749.           || (strpos($GLOBALS['collation_connection'], '_')
  750.                 ? substr($GLOBALS['collation_connection'], 0, strpos($GLOBALS['collation_connection'], '_'))
  751.                 : $GLOBALS['collation_connection']) == $mysql_charset) {
  752.  
  753.             PMA_DBI_query('SET NAMES ' . $mysql_charset . ';', $link,
  754.                 PMA_DBI_QUERY_STORE);
  755.         } else {
  756.             PMA_DBI_query('SET CHARACTER SET ' . $mysql_charset . ';', $link,
  757.                 PMA_DBI_QUERY_STORE);
  758.         }
  759.         if (!empty($GLOBALS['collation_connection'])) {
  760.             PMA_DBI_query('SET collation_connection = \'' . $GLOBALS['collation_connection'] . '\';',
  761.                 $link, PMA_DBI_QUERY_STORE);
  762.         }
  763.         if (!$is_controluser) {
  764.             $GLOBALS['collation_connection'] = PMA_DBI_get_variable('collation_connection',
  765.                 PMA_DBI_GETVAR_SESSION, $link);
  766.             $GLOBALS['charset_connection']   = PMA_DBI_get_variable('character_set_connection',
  767.                 PMA_DBI_GETVAR_SESSION, $link);
  768.         }
  769.  
  770.         // Add some field types to the list, this needs to be done once per session!
  771.         if ($GLOBALS['cfg']['ColumnTypes'][count($GLOBALS['cfg']['ColumnTypes']) - 1] != 'VARBINARY') {
  772.             $GLOBALS['cfg']['ColumnTypes'][] = 'BINARY';
  773.             $GLOBALS['cfg']['ColumnTypes'][] = 'VARBINARY';
  774.         }
  775.  
  776.     } else {
  777.         require_once('./libraries/charset_conversion.lib.php');
  778.     }
  779. }
  780.  
  781. /**
  782.  * returns a single value from the given result or query,
  783.  * if the query or the result has more than one row or field
  784.  * the first field of the first row is returned
  785.  *
  786.  * <code>
  787.  * $sql = 'SELECT `name` FROM `user` WHERE `id` = 123';
  788.  * $user_name = PMA_DBI_fetch_value( $sql );
  789.  * // produces
  790.  * // $user_name = 'John Doe'
  791.  * </code>
  792.  *
  793.  * @uses    is_string()
  794.  * @uses    is_int()
  795.  * @uses    PMA_DBI_try_query()
  796.  * @uses    PMA_DBI_num_rows()
  797.  * @uses    PMA_DBI_fetch_row()
  798.  * @uses    PMA_DBI_fetch_assoc()
  799.  * @uses    PMA_DBI_free_result()
  800.  * @param   string|mysql_result $result query or mysql result
  801.  * @param   integer             $row_number row to fetch the value from,
  802.  *                                      starting at 0, with 0 beeing default
  803.  * @param   integer|string      $field  field to fetch the value from,
  804.  *                                      starting at 0, with 0 beeing default
  805.  * @param   resource            $link   mysql link
  806.  * @param   mixed               $options
  807.  * @return  mixed               value of first field in first row from result
  808.  *                              or false if not found
  809.  */
  810. function PMA_DBI_fetch_value( $result, $row_number = 0, $field = 0, $link = null, $options = 0 ) {
  811.     $value = false;
  812.  
  813.     if ( is_string( $result ) ) {
  814.         $result = PMA_DBI_try_query( $result, $link, $options | PMA_DBI_QUERY_STORE );
  815.     }
  816.  
  817.     // return false if result is empty or false
  818.     // or requested row is larger than rows in result
  819.     if ( PMA_DBI_num_rows( $result ) < ( $row_number + 1 ) ) {
  820.         return $value;
  821.     }
  822.  
  823.     // if $field is an integer use non associative mysql fetch function
  824.     if ( is_int( $field ) ) {
  825.         $fetch_function = 'PMA_DBI_fetch_row';
  826.     } else {
  827.         $fetch_function = 'PMA_DBI_fetch_assoc';
  828.     }
  829.  
  830.     // get requested row
  831.     for ( $i = 0; $i <= $row_number; $i++ ) {
  832.         $row = $fetch_function( $result );
  833.     }
  834.     PMA_DBI_free_result( $result );
  835.  
  836.     // return requested field
  837.     if ( isset( $row[$field] ) ) {
  838.         $value = $row[$field];
  839.     }
  840.     unset( $row );
  841.  
  842.     return $value;
  843. }
  844.  
  845. /**
  846.  * returns only the first row from the result
  847.  *
  848.  * <code>
  849.  * $sql = 'SELECT * FROM `user` WHERE `id` = 123';
  850.  * $user = PMA_DBI_fetch_single_row( $sql );
  851.  * // produces
  852.  * // $user = array( 'id' => 123, 'name' => 'John Doe' )
  853.  * </code>
  854.  *
  855.  * @uses    is_string()
  856.  * @uses    PMA_DBI_try_query()
  857.  * @uses    PMA_DBI_num_rows()
  858.  * @uses    PMA_DBI_fetch_row()
  859.  * @uses    PMA_DBI_fetch_assoc()
  860.  * @uses    PMA_DBI_fetch_array()
  861.  * @uses    PMA_DBI_free_result()
  862.  * @param   string|mysql_result $result query or mysql result
  863.  * @param   string              $type   NUM|ASSOC|BOTH
  864.  *                                      returned array should either numeric
  865.  *                                      associativ or booth
  866.  * @param   resource            $link   mysql link
  867.  * @param   mixed               $options
  868.  * @return  array|boolean       first row from result
  869.  *                              or false if result is empty
  870.  */
  871. function PMA_DBI_fetch_single_row( $result, $type = 'ASSOC', $link = null, $options = 0 ) {
  872.     if ( is_string( $result ) ) {
  873.         $result = PMA_DBI_try_query( $result, $link, $options | PMA_DBI_QUERY_STORE );
  874.     }
  875.  
  876.     // return null if result is empty or false
  877.     if ( ! PMA_DBI_num_rows( $result ) ) {
  878.         return false;
  879.     }
  880.  
  881.     switch ( $type ) {
  882.         case 'NUM' :
  883.             $fetch_function = 'PMA_DBI_fetch_row';
  884.             break;
  885.         case 'ASSOC' :
  886.             $fetch_function = 'PMA_DBI_fetch_assoc';
  887.             break;
  888.         case 'BOTH' :
  889.         default :
  890.             $fetch_function = 'PMA_DBI_fetch_array';
  891.             break;
  892.     }
  893.  
  894.     $row = $fetch_function( $result );
  895.     PMA_DBI_free_result( $result );
  896.     return $row;
  897. }
  898.  
  899. /**
  900.  * returns all rows in the resultset in one array
  901.  *
  902.  * <code>
  903.  * $sql = 'SELECT * FROM `user`';
  904.  * $users = PMA_DBI_fetch_result( $sql );
  905.  * // produces
  906.  * // $users[] = array( 'id' => 123, 'name' => 'John Doe' )
  907.  *
  908.  * $sql = 'SELECT `id`, `name` FROM `user`';
  909.  * $users = PMA_DBI_fetch_result( $sql, 'id' );
  910.  * // produces
  911.  * // $users['123'] = array( 'id' => 123, 'name' => 'John Doe' )
  912.  *
  913.  * $sql = 'SELECT `id`, `name` FROM `user`';
  914.  * $users = PMA_DBI_fetch_result( $sql, 0 );
  915.  * // produces
  916.  * // $users['123'] = array( 0 => 123, 1 => 'John Doe' )
  917.  *
  918.  * $sql = 'SELECT `id`, `name` FROM `user`';
  919.  * $users = PMA_DBI_fetch_result( $sql, 'id', 'name' );
  920.  * // or
  921.  * $users = PMA_DBI_fetch_result( $sql, 0, 1 );
  922.  * // produces
  923.  * // $users['123'] = 'John Doe'
  924.  *
  925.  * $sql = 'SELECT `name` FROM `user`';
  926.  * $users = PMA_DBI_fetch_result( $sql );
  927.  * // produces
  928.  * // $users[] = 'John Doe'
  929.  * </code>
  930.  *
  931.  * @uses    is_string()
  932.  * @uses    is_int()
  933.  * @uses    PMA_DBI_try_query()
  934.  * @uses    PMA_DBI_num_rows()
  935.  * @uses    PMA_DBI_num_fields()
  936.  * @uses    PMA_DBI_fetch_row()
  937.  * @uses    PMA_DBI_fetch_assoc()
  938.  * @uses    PMA_DBI_free_result()
  939.  * @param   string|mysql_result $result query or mysql result
  940.  * @param   string|integer      $key    field-name or offset
  941.  *                                      used as key for array
  942.  * @param   string|integer      $value  value-name or offset
  943.  *                                      used as value for array
  944.  * @param   resource            $link   mysql link
  945.  * @param   mixed               $options
  946.  * @return  array               resultrows or values indexed by $key
  947.  */
  948. function PMA_DBI_fetch_result( $result, $key = null, $value = null,
  949.     $link = null, $options = 0 )
  950. {
  951.     $resultrows = array();
  952.  
  953.     if ( is_string($result) ) {
  954.         $result = PMA_DBI_try_query($result, $link, $options);
  955.     }
  956.  
  957.     // return empty array if result is empty or false
  958.     if ( ! $result ) {
  959.         return $resultrows;
  960.     }
  961.  
  962.     $fetch_function = 'PMA_DBI_fetch_assoc';
  963.  
  964.     // no nested array if only one field is in result
  965.     if ( null === $key && 1 === PMA_DBI_num_fields($result) ) {
  966.         $value = 0;
  967.         $fetch_function = 'PMA_DBI_fetch_row';
  968.     }
  969.  
  970.     // if $key is an integer use non associative mysql fetch function
  971.     if ( is_int($key) ) {
  972.         $fetch_function = 'PMA_DBI_fetch_row';
  973.     }
  974.  
  975.     if ( null === $key && null === $value ) {
  976.         while ( $row = $fetch_function($result) ) {
  977.             $resultrows[] = $row;
  978.         }
  979.     } elseif ( null === $key ) {
  980.         while ( $row = $fetch_function($result) ) {
  981.             $resultrows[] = $row[$value];
  982.         }
  983.     } elseif ( null === $value ) {
  984.         if ( is_array($key) ) {
  985.             while ( $row = $fetch_function($result) ) {
  986.                 $result_target =& $resultrows;
  987.                 foreach ( $key as $key_index ) {
  988.                     if ( ! isset( $result_target[$row[$key_index]] ) ) {
  989.                         $result_target[$row[$key_index]] = array();
  990.                     }
  991.                     $result_target =& $result_target[$row[$key_index]];
  992.                 }
  993.                 $result_target = $row;
  994.             }
  995.         } else {
  996.             while ( $row = $fetch_function($result) ) {
  997.                 $resultrows[$row[$key]] = $row;
  998.             }
  999.         }
  1000.     } else {
  1001.         if ( is_array($key) ) {
  1002.             while ( $row = $fetch_function($result) ) {
  1003.                 $result_target =& $resultrows;
  1004.                 foreach ( $key as $key_index ) {
  1005.                     if ( ! isset( $result_target[$row[$key_index]] ) ) {
  1006.                         $result_target[$row[$key_index]] = array();
  1007.                     }
  1008.                     $result_target =& $result_target[$row[$key_index]];
  1009.                 }
  1010.                 $result_target = $row[$value];
  1011.             }
  1012.         } else {
  1013.             while ( $row = $fetch_function($result) ) {
  1014.                 $resultrows[$row[$key]] = $row[$value];
  1015.             }
  1016.         }
  1017.     }
  1018.  
  1019.     PMA_DBI_free_result($result);
  1020.     return $resultrows;
  1021. }
  1022.  
  1023. /**
  1024.  * return default table engine for given database
  1025.  *
  1026.  * @return  string  default table engine
  1027.  */
  1028. function PMA_DBI_get_default_engine()
  1029. {
  1030.     if ( PMA_MYSQL_INT_VERSION > 50002 ) {
  1031.         return PMA_DBI_fetch_value( 'SHOW VARIABLES LIKE \'storage_engine\';', 0, 1 );
  1032.     } else {
  1033.         return PMA_DBI_fetch_value( 'SHOW VARIABLES LIKE \'table_type\';', 0, 1 );
  1034.     }
  1035. }
  1036.  
  1037. ?>
  1038.